Transforming Procedural Program Structures to Object-Oriented Class Structures for the Purpose of Populating a Common Software Repository

The purpose of the }i-'ork presented here is to convert the design documentation of procedural application systems into an object-oriented design for the purpose of populating an object-oriented repository, The prerequisite is to have a single design representation -the object model as specified in the OMG Unified Modeling Language, That entails transforming procedural programs into class hierarchies as described in this paper, The technique used is an adaptation of the dominance tree approach described in previous papers from Burd and Munro combined }i-'ith the precedence graphs proposed by Horwitz and Reps, comma separated value file generated from the source code by the source analysis tools, one for associating functions with sections, one for relating functions to other functions, one to relate functions to the data they use and one to assign data items to data structures. Base Section Target Function Base Function Target Function Base Function Target Data Base Data Target Data Given that all function connections are depicted in the function/function matrix a dependence graph is used to determine the level at which a procedure is no longer dependent on a subordinate procedure. It is there where it's functions to not use any other lower level functions. If a function is the target of two or more higher level functions it is duplicated so that the same function node is now contained in different branches of the function tree. This is really only a virtual duplication since of course the function only exists once in the repository. However, there are links to it from different nodes of the tree. In the resulting object model this will result in multiple inheritance. This author has created an object-oriented software repository built on class hierarchies and method associations. However, since object-oriented systems written in C++ and Java are often integrated with procedural systems written in C,COBOL, PLI or Assembler it is required to include the latter systems in the repository. For this their architectural representation must be mapped into an objectoriented one prior to storage in the repository. The principal mapping challenge is to map procedures into classes. This is the same challenge as that faced by researchers in extracting objects from procedural code. For that many algorithms have been proposed in the pertinent literature. The algorithm used here is designed to create an objectoriented representation of procedural structures, but it could also be used to transform procedural programs into object-oriented components. It is a retrofitting algorithm based on dominance trees and dependence graphs which maps interdependent procedures using a common data area into encapsulated classes each with their own attributes. In the new class hierarchy those procedures or sections at the bottom of the procedural hierarchy are now at top of the class hierarchy, meaning that all functions which use them are now below them in the class hierarchy. The parent nodes have become the sub-nodes. Those elementary procedures which do not refer to any other procedures, i.e. the independent ones, are the super classes. The functions of a super class can only be target functions. They can not refer to any other functions other than those in the same class. The functions below them are assigned to classes based on their sub-nodes in the inverted tree. If a function refers to a lower level function and is itself referred to by one or more higher level functions, then it is clustered together with those functions at the same level referred to by the same higher level functions. This leads to a clustering of functions into classes by having common dependent functions, a technique originally proposed by Horwitz and Reps. A class is then a set of parent nodes in the inverted tree which have the same sub-nodes, i. e. functions which are referred to by the same higher level functions. This amounts to an inversion of the program dominance trees described by Burd and Monroe. To convert procedures into classes it is necessary to invert the procedural hierarchy putting the subroutines at the top of the class hierarchy and to filter the data down to the lowest level possible. The assumption is that functions are connected together by the use of common data or by the use of common subroutines. The mapping task is to map a network of functions with a single data store onto a tree of functions with multiple data stores. The transfonnation process begins by creating four connectivity matrices from the relationship table in a 1063-6773/02 $17.00 @ 2002 IEEE 286 Proceedings of the International Conference on Software Maintenance (ICSM’02) 0-7695-1819-2/02 $17.00 © 2002 IEEE